{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "MVNN_prediction_new_set.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "xsxqK2wRlNvD"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AyushGupta51379/COMP_5331_Project_Fake_News_Detection/blob/master/MVNN_prediction_new_set.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ghzNr1TklPAR"
      },
      "source": [
        "# MVNN\n",
        "\n",
        "This piece of work is an implementation of Multi-domain Visual Neural Network (MVNN), which is first proposed in the paper [Exploiting Multi-domain Visual Information for Fake News Detection](https://arxiv.org/abs/1908.04472)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vYmmpTvxlII9"
      },
      "source": [
        "# some basic things to include\n",
        "import os\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torchvision import datasets, transforms\n",
        "\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "\n",
        "# some preprocessing techniques\n",
        "from scipy.fftpack import dct\n",
        "\n",
        "# custom dataset\n",
        "from torch.utils.data.dataset import Dataset\n",
        "\n",
        "# this is only required for Google Colab\n",
        "from google.colab import drive\n",
        "\n",
        "import time\n",
        "from datetime import datetime\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsuzqnBVpuAR"
      },
      "source": [
        "these modules and dataset require to be downloaded (unless they are executed under a repository)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OsFX9EkSmXxF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ddfdf401-935d-4fc9-d9ab-ac51b32199e1"
      },
      "source": [
        "# DCT modules\n",
        "#print(\"DCT Module:\")\n",
        "#!gdown --id 1MtVZXrFkLTLQgOhFhbYIUrXT-FMKH2hH\n",
        "#from dct import DCT, DFT\n",
        "\n",
        "# download the Weibo dataset\n",
        "# !gdown --id 1gjbSZV5NjjIVOqSP-yTCqXcGPX9PnYn5\n",
        "# !unzip -q '/content/MM17-WeiboRumorSet.zip'\n",
        "# mainfolder = 'MM17-WeiboRumorSet/'\n",
        "# subfolders = {'nonrumor_images': 0, 'rumor_images': 1}\n",
        "# print(\"Dataset: Weibo is loaded\")\n",
        "\n",
        "# download the Twitter dataset\n",
        "!gdown --id 1ydEupxLKCmFYe3nfbpbRyCmHi05Oxt5i\n",
        "!unzip -q '/content/Medieval2015_fake_or_real_Images.zip'\n",
        "mainfolder = 'Medieval2015_fake_or_real_Images/'\n",
        "subfolders = {'non-rumor': 0, 'rumor': 1}\n",
        "print(\"Dataset: Twitter is loaded\")"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1ydEupxLKCmFYe3nfbpbRyCmHi05Oxt5i\n",
            "To: /content/Medieval2015_fake_or_real_Images.zip\n",
            "35.3MB [00:00, 46.2MB/s]\n",
            "Dataset: Twitter is loaded\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jLz9GPSIgczE"
      },
      "source": [
        "\n",
        "'''\n",
        "Usage:\n",
        "as image preprocessor by calling DCT() as a transform\n",
        "\n",
        "input: 128*128*3 PIL image\n",
        "output: 64*256 torch array (histogram)\n",
        "\n",
        "[128*128] => (crop) => [256 * [8*8]] => (DCT_2d) => [256 * [8 * 8]] => reshape => [256 * 64]  \n",
        "'''\n",
        "\n",
        "class DCT(object):\n",
        "    def __init__(self):\n",
        "        self.BLOCK_HEIGHT = 8\n",
        "        self.BLOCK_WIDTH = 8\n",
        "        self.BLOCK_SIZE = (self.BLOCK_HEIGHT, self.BLOCK_WIDTH)\n",
        "\n",
        "    def div_block(self, img, block_size):\n",
        "        img_height = img.height\n",
        "        img_width = img.width\n",
        "        block_height = block_size[0]\n",
        "        block_width = block_size[1]\n",
        "        assert(img_height % block_height == 0)\n",
        "        assert(img_width % block_width == 0)\n",
        "\n",
        "        blocks = []\n",
        "        for i in range(0,img_height,block_height):\n",
        "            for j in range(0,img_width,block_width):\n",
        "                box = (j, i, j+block_width, i+block_height)\n",
        "                block = np.array(img.crop(box))\n",
        "                blocks.append(block)\n",
        "        return np.array(blocks)\n",
        "\n",
        "    def dct2(self, array_2d):\n",
        "        return dct(dct(array_2d.T, norm = 'ortho').T, norm = 'ortho')\n",
        "\n",
        "    def _dct2(self, array_2d):\n",
        "        return dct(dct(array_2d, norm = 'ortho').T, norm = 'ortho').T\n",
        "\n",
        "    def __call__(self, img):\n",
        "        image = img\n",
        "        blocks = self.div_block(image, self.BLOCK_SIZE)\n",
        "        b_blocks, g_blocks, r_blocks = blocks[:, :, :, 0], blocks[:, :, :, 1], blocks[:, :, :, 2]\n",
        "        test_blocks = (b_blocks + g_blocks + r_blocks) / 3 # naive greyscale\n",
        "        result = np.array([self._dct2(test_block) for test_block in test_blocks])\n",
        "        # return a torch.tensor\n",
        "        return torch.from_numpy(result.reshape(256, 64).T).float()\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Simply DCT. What do you expect?\"\n",
        "\n",
        "'''\n",
        "Usage: Same as DCT()\n",
        "\n",
        "input: 64*256 torch array (histogram)\n",
        "output: 64*256 torch array (frequency histogram)\n",
        "'''\n",
        "class DFT(object):\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def __call__(self, freq):\n",
        "        # convert into complex form containing real and imaginary part\n",
        "        cmplx = torch.from_numpy(np.zeros((freq.shape[0], freq.shape[1], 2)))\n",
        "        cmplx[:, :, 0] += freq\n",
        "        out = torch.fft(cmplx, 1, normalized=True)[:, :, 0]\n",
        "        return out\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Simply DFT. What do you expect?\"\n",
        "\n",
        "\n",
        "'''\n",
        "input: PIL loaded image\n",
        "output: PIL image, in YCbCr color space\n",
        "'''\n",
        "class Ycbcr_convert():\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def __call__(self, img):\n",
        "        return img.convert('YCbCr')\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Convert a PIL Image from RGB to YCbCr\" "
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ayTY1AY3miLq"
      },
      "source": [
        "## Image transformers for pixel and freq domain"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AeTQn2uZmX2r"
      },
      "source": [
        "## Define the image transformers for pixel and freq domain\n",
        "\n",
        "image_height_pixel, image_width_pixel = 224, 224\n",
        "image_height_freq, image_width_freq = 128, 128\n",
        "tform_pixel = transforms.Compose([\n",
        "    transforms.Resize((image_height_pixel,image_width_pixel), interpolation=Image.BICUBIC),\n",
        "    transforms.ToTensor()\n",
        "])\n",
        "tform_freq = transforms.Compose([\n",
        "    transforms.Resize((image_height_freq,image_width_freq), interpolation=Image.BICUBIC),\n",
        "    Ycbcr_convert(),\n",
        "    DCT(),\n",
        "    # DFT()\n",
        "])\n",
        "\n",
        "def imshow(np_image):\n",
        "    plt.figure(figsize = (5,5))\n",
        "    plt.imshow(np_image) # it should be a numpy array\n",
        "    plt.show()"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4nas4CoTsRqC"
      },
      "source": [
        "### Some remarks from AG  \n",
        "When you use GPU runtime in Colab, apart from the original VM running the notebook, Google will instantiate a new VM with GPU so that parallel computations are forwarded to VM with GPU. \\\\\n",
        "Here we load all the data (~1.35GB, while Nvidia Tesla K80 has 12GB RAM) into memory in the beginning. Hence the data transfer between 2 VMs will only be called once, rather than every mini-batch. This is the point which takes most time, while in the training section later it will exhibit huge speedup."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4sNJgGvkmX5z"
      },
      "source": [
        "class WeiboRumorDataset(Dataset):\n",
        "    def __init__(self, tform_pixel, tform_freq, folder, subfolders):        \n",
        "        self.tform_pixel = tform_pixel\n",
        "        self.tform_freq = tform_freq\n",
        "        self.mainfolder = folder\n",
        "        self.subfolders = subfolders        \n",
        "        self.data = []\n",
        "        # load the entire dataset into memory\n",
        "        for subfolder, label in subfolders.items():\n",
        "            current = os.path.join(self.mainfolder, subfolder)\n",
        "            filenames = os.listdir(current)\n",
        "            for filename in filenames:\n",
        "                self.data.append([os.path.join(subfolder, filename), label])\n",
        "            print(\"[%s]: %d image loaded.\" % (current, len(filenames)))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        if torch.is_tensor(idx):\n",
        "            idx = idx.tolist()\n",
        "\n",
        "        filepath, label = self.data[idx]\n",
        "        img = Image.open(os.path.join(self.mainfolder, filepath)).convert('RGB')     \n",
        "        pixel_input = self.tform_pixel(img)\n",
        "        freq_input = self.tform_freq(img)\n",
        "        out = [pixel_input, freq_input, label]\n",
        "        return out"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AxFdeFBD0icA",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 408
        },
        "outputId": "fe795f83-50a9-460e-e30e-1b993a430291"
      },
      "source": [
        "# visualize information of the dataset\n",
        "\n",
        "dataset = WeiboRumorDataset(tform_pixel, tform_freq, mainfolder, subfolders)\n",
        "count = dataset.__len__()\n",
        "print('Total no. of images: ', count)\n",
        "\n",
        "pixel_input, freq_input, label = dataset.__getitem__(0)\n",
        "imshow(pixel_input.transpose(0, 1).transpose(1, 2))\n",
        "print(\"Frequency domain shape:\", freq_input.shape)\n",
        "print(\"Label:\", label)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[Medieval2015_fake_or_real_Images/non-rumor]: 176 image loaded.\n",
            "[Medieval2015_fake_or_real_Images/rumor]: 184 image loaded.\n",
            "Total no. of images:  360\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Frequency domain shape: torch.Size([64, 256])\n",
            "Label: 0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xsxqK2wRlNvD"
      },
      "source": [
        "## Subnetworks"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iSzJzDbwsKAt"
      },
      "source": [
        "class CNN(nn.Module):\n",
        "    def __init__(self, image_height, image_width):\n",
        "        super(CNN, self).__init__()\n",
        "\n",
        "        # NOTE:\n",
        "        # 1. Before each ReLu, a BatchNorm2d layer is added to accelerate convergence (also did by the authors of the paper)\n",
        "\n",
        "        # Conv Model 1\n",
        "        self.conv_M1 = nn.Sequential(nn.Conv2d( 3, 32, 3, padding = 1), nn.BatchNorm2d(32), nn.ReLU(),   # (N,  3, 128, 128) --> (N, 32, 128, 128); add padding = 1 for kernel size = 3 to avoid changing output size\n",
        "                                     nn.Conv2d(32, 32, 1), nn.BatchNorm2d(32), nn.ReLU(),                # (N, 32, 128, 128) --> (N, 32, 128, 128);\n",
        "                                     nn.MaxPool2d(2))                                                    # (N,  3, 128, 128) --> (N, 32,  64,  64);\n",
        "                                     \n",
        "        # Conv Model 2\n",
        "        self.conv_M2 = nn.Sequential(nn.Conv2d(32, 64, 3, padding = 1), nn.BatchNorm2d(64), nn.ReLU(),  # (N, 32, 64, 64) --> (N, 64, 64, 64)\n",
        "                                     nn.Conv2d(64, 64, 1), nn.BatchNorm2d(64), nn.ReLU(),               # (N, 64, 64, 64) --> (N, 64, 64, 64)\n",
        "                                     nn.MaxPool2d(2))                                                   # (N, 64, 64, 64) --> (N, 64, 32, 32)\n",
        "\n",
        "        # Conv Model 3\n",
        "        self.conv_M3 = nn.Sequential(nn.Conv2d(64, 64, 3, padding = 1), nn.BatchNorm2d(64), nn.ReLU(),  # (N, 64, 32, 32) --> (N, 64, 32, 32)\n",
        "                                     nn.Conv2d(64, 64, 1), nn.BatchNorm2d(64), nn.ReLU(),               # (N, 64, 32, 32) --> (N, 64, 32, 32)\n",
        "                                     nn.MaxPool2d(2))                                                   # (N, 64, 32, 32) --> (N, 64, 16, 16)\n",
        "\n",
        "        # Conv Model 4\n",
        "        self.conv_M4 = nn.Sequential(nn.Conv2d( 64, 128, 3, padding = 1), nn.BatchNorm2d(128), nn.ReLU(), # (N,  64, 16, 16) --> (N, 128, 16, 16)\n",
        "                                     nn.Conv2d(128, 128, 1), nn.BatchNorm2d(128), nn.ReLU(),              # (N, 128, 16, 16) --> (N, 128, 16, 16)\n",
        "                                     nn.MaxPool2d(2))                                                     # (N, 128, 16, 16) --> (N, 128,  8,  8)\n",
        "        \n",
        "        #===== For each branch =====%\n",
        "        # Note:\n",
        "        # 1. Flatten convolution layer before FC layer, the input column size = 64 neurons * pooled output size\n",
        "        # 2. Since image_height and image_width are fed from outside, we need to ensure the type to int after division, otherwise gives bugs.\n",
        "        # 3. Need to add a dropout layer with a prob of 0.5 after FC layer (see the reference paper)\n",
        "        # 4. Before each FC layer, a BatchNorm2d layer is added to accelerate convergence\n",
        "\n",
        "        self.conv_br1 = nn.Sequential(nn.Conv2d(32, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),    # flatten from the 2nd dim (1) to the last dim (-1)\n",
        "                                      nn.Linear(int(64*image_height*image_width/2/2), 64),\n",
        "                                      nn.BatchNorm1d(64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br2 = nn.Sequential(nn.Conv2d(64, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),              \n",
        "                                      nn.Linear(int(64*image_height*image_width/4/4), 64),\n",
        "                                      nn.BatchNorm1d(64),  \n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br3 = nn.Sequential(nn.Conv2d(64, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),    \n",
        "                                      nn.Linear(int(64*image_height*image_width/8/8), 64),\n",
        "                                      nn.BatchNorm1d(64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br4 = nn.Sequential(nn.Conv2d(128, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),              \n",
        "                                      nn.Linear(int(64*image_height*image_width/16/16), 64),\n",
        "                                      nn.BatchNorm1d(64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        # FC layer to 2 classes (fake or real) with Softmax to compute prob along the dimension of concatenated features (64*4 = 256)\n",
        "        self.fc = nn.Sequential(nn.Linear(256, 2),\n",
        "                                nn.Dropout(0.5))    \n",
        "                                        #nn.Softmax(dim=1)) # AG: no need for softmax if we use cross entropy loss function, which will also offer prob.\n",
        "                                                            # Now the loss in the training part converges!!\n",
        "    \n",
        "    def forward(self, x):\n",
        "        out1 = self.conv_M1(x)      # Branch 1\n",
        "        out2 = self.conv_M2(out1)   # Branch 2\n",
        "        out3 = self.conv_M3(out2)   # Branch 3\n",
        "        out4 = self.conv_M4(out3)   # Branch 4\n",
        "        v1 = self.conv_br1(out1)\n",
        "        v2 = self.conv_br2(out2)\n",
        "        v3 = self.conv_br3(out3)\n",
        "        v4 = self.conv_br4(out4)\n",
        "        v_cat = torch.cat((v1, v2, v3, v4), dim=1)\n",
        "        # p = self.fc(v_cat)\n",
        "\n",
        "        # print(\"\\n v1 size:\", v1.shape)\n",
        "        # print(\"\\n v2 size:\", v2.shape)\n",
        "        # print(\"\\n v3 size:\", v3.shape)\n",
        "        # print(\"\\n v4 size:\", v4.shape)\n",
        "        # print(\"\\n v_cat size:\", v_cat.shape)\n",
        "        return v1, v2, v3, v4\n",
        "\n",
        "class CNN_GRU(CNN):\n",
        "    def __init__(self, image_height, image_width):\n",
        "        super(CNN_GRU, self).__init__(image_height, image_width)\n",
        "\n",
        "        # The 4 GRUs in layer 1\n",
        "        self.gru1_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru2_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru3_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru4_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "\n",
        "        # The 4 GRUs in layer 2\n",
        "        self.gru1_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru2_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru3_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru4_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "\n",
        "        self.relu = nn.ReLU()\n",
        "\n",
        "        self.bn = nn.BatchNorm1d(4*2*32)\n",
        "        self.fc = nn.Sequential(nn.Linear(4*2*32, 2))\n",
        "                                            # nn.LogSoftmax(dim=1)) # AG: no need for softmax if we use cross entropy loss function, which will also offer prob.\n",
        "                                                            # Now the loss in the training part converges!!\n",
        "    def forward(self, x):\n",
        "        v1, v2, v3, v4 = super().forward(x)\n",
        "        \n",
        "        v1 = v1.unsqueeze(0) # add an extra dimension to feed into the gru model (4, 64) --> (1, 4, 64)\n",
        "        v2 = v2.unsqueeze(0)\n",
        "        v3 = v3.unsqueeze(0)\n",
        "        v4 = v4.unsqueeze(0)\n",
        "\n",
        "        # backward GRU (1st layer) which reads from v4 to v1 \n",
        "        out4_layer1, h4_backward = self.gru4_1(v4)                  # --> (1, N, 32)\n",
        "        out3_layer1, h3_backward = self.gru3_1(v3, h4_backward)\n",
        "        out2_layer1, h2_backward = self.gru2_1(v2, h3_backward)\n",
        "        out1_layer1, h1_backward = self.gru1_1(v1, h2_backward)\n",
        "\n",
        "\n",
        "        # forward GRU (2nd layer) which reads from v1 to v4 \n",
        "        out1_layer2, h1_forward = self.gru1_2(h1_backward)          # --> (1, N, 32)\n",
        "        out2_layer2, h2_forward = self.gru2_2(h2_backward, h1_backward)\n",
        "        out3_layer2, h3_forward = self.gru3_2(h3_backward, h2_backward)\n",
        "        out4_layer2, h4_forward = self.gru4_2(h4_backward, h3_backward)\n",
        "\n",
        "        # concatenating the forward hidden state and the backward hidden state along the feature dimension --> (1, N, 64)\n",
        "        L1 = torch.squeeze(torch.cat((h1_forward, h1_backward), dim=2)) # --> (N, 64)\n",
        "        L2 = torch.squeeze(torch.cat((h2_forward, h2_backward), dim=2))\n",
        "        L3 = torch.squeeze(torch.cat((h3_forward, h3_backward), dim=2))\n",
        "        L4 = torch.squeeze(torch.cat((h4_forward, h4_backward), dim=2))\n",
        "\n",
        "        # print(\"\\n L1 size:\", L1.shape)\n",
        "        # print(\"\\n L2 size:\", L2.shape)\n",
        "        # print(\"\\n L3 size:\", L3.shape)\n",
        "        # print(\"\\n L4 size:\", L4.shape)\n",
        "\n",
        "        L_cat = torch.cat((L1, L2, L3, L4), dim=1)    # --> (4, N, 32)\n",
        "        # print(\"\\n L_cat size:\", L_cat.shape)\n",
        "        \n",
        "        # p = self.fc(self.bn(L_cat))\n",
        "\n",
        "        return L1, L2, L3, L4, L_cat\n",
        "\n",
        "class Frequent_Domain_Subnetwork(nn.Module):\n",
        "    def __init__(self):\n",
        "            super(Frequent_Domain_Subnetwork, self).__init__()\n",
        "            self.backbone = nn.Sequential(nn.Conv1d(64, 32, 3, padding=1),\n",
        "                                nn.BatchNorm1d(32),\n",
        "                                nn.ReLU(),\n",
        "                                nn.MaxPool1d(2),\n",
        "                                nn.Conv1d(32, 64, 3, padding=1),\n",
        "                                nn.BatchNorm1d(64),\n",
        "                                nn.ReLU(),\n",
        "                                nn.MaxPool1d(2),\n",
        "                                nn.Conv1d(64, 128, 3, padding=1),\n",
        "                                nn.BatchNorm1d(128),\n",
        "                                nn.ReLU(),\n",
        "                                nn.MaxPool1d(2),\n",
        "                                nn.Flatten(),\n",
        "                                nn.Linear(4096, 64),\n",
        "                                nn.ReLU(),\n",
        "                                nn.Linear(64, 64))\n",
        "            \n",
        "    def forward(self, x):\n",
        "        out = self.backbone.forward(x)\n",
        "        return out    "
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GGtmk4wxn8nb"
      },
      "source": [
        "# Models"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nkgAG_e7terO"
      },
      "source": [
        "#=========== Model 1, full MVNN model\n",
        "class MVNN(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN_GRU(image_height_pixel, image_width_pixel)\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # attention\n",
        "        self.output_len = 5\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        L1, L2, L3, L4, L_cat = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L0, L1, L2, L3, L4), dim=1) # Bx5x64\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx5x64 bmm 1x64x1 => Bx5x1 => Bx5\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x5 bmm Bx5x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out        \n",
        "\n",
        "#=========== Model 2, w/o freq\n",
        "class MVNN_wout_freq(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN_GRU(image_height_pixel, image_width_pixel)\n",
        "        # self.freq_subnet = Frequent_Domain_Subnetwork()     \n",
        "\n",
        "        # attention\n",
        "        self.output_len = 5\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        L1, L2, L3, L4, L_cat = self.pixel_subnet(x_pixel)      \n",
        "        # L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L1, L2, L3, L4), dim=1) # Bx4x64\n",
        "        # L_all = torch.stack((L0, L1, L2, L3, L4), dim=1) # Bx5x64\n",
        "\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx4x64 bmm 1x64x1 => Bx5x1 => Bx5\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x5 bmm Bx5x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out      \n",
        "\n",
        "#=========== Model 3, MVNN w/o pixel and attention\n",
        "class MVNN_wout_pixel(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(64, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "\n",
        "        L0 = self.freq_subnet(x_freq)  # Bx64\n",
        "        out = self.Wc(L0) # final output: Bx2\n",
        "        return out\n",
        "\n",
        "\n",
        "#=========== Model 4, full MVNN w/o attention\n",
        "class MVNN_wout_att(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN_GRU(image_height_pixel, image_width_pixel)\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(64*5, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "\n",
        "        L1, L2, L3, L4, L_cat = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.cat((L0, L1, L2, L3, L4), dim=1) # Bx320\n",
        "        out = self.Wc(L_all) # final output: Bx2\n",
        "        return out\n",
        "\n",
        "#=========== Model 5, MVNN w/o GRU\n",
        "class MVNN_wout_GRU(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN(image_height_pixel, image_width_pixel) #<-- use CNN instead of CNN_GRU\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # attention\n",
        "        self.output_len = 5\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        v1, v2, v3, v4 = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L0, v1, v2, v3, v4), dim=1) # Bx5x64\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx5x64 bmm 1x64x1 => Bx5x1 => Bx5\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x5 bmm Bx5x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out\n",
        "\n",
        "#=========== Model 6, MVNN w/o branches (and GRU)\n",
        "class MVNN_wout_branches(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN(image_height_pixel, image_width_pixel) #<-- use CNN instead of CNN_GRU\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # attention\n",
        "        self.output_len = 2\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        _, _, _, v4 = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L0, v4), dim=1) # Bx2x64\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx2x64 bmm 1x64x1 => Bx2x1 => Bx2\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x2 bmm Bx2x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out  "
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8-42A7280gQH"
      },
      "source": [
        "## Metrics for model evaluation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3EdG2-b6Yju4"
      },
      "source": [
        "from sklearn.metrics import accuracy_score # normal accuracy\n",
        "from sklearn.metrics import balanced_accuracy_score # used in case of imbalanced data sets, average of recall, from 0 to 1\n",
        "from sklearn.metrics import confusion_matrix # division of performance on the multilabels\n",
        "from sklearn.metrics import cohen_kappa_score # compares model against random prediction, from -1 to 1\n",
        "from sklearn.metrics import classification_report # for multilabel classification, gives precision, recall, f score, support, more\n",
        "\n",
        "def print_metrics(y_true, y_pred, target_names):\n",
        "    print(\"Accuracy:\", accuracy_score(y_true, y_pred))\n",
        "    print(\"Balanced Accuracy:\" , balanced_accuracy_score(y_true, y_pred))\n",
        "    print(\"Confusion Matrix:\\n\", confusion_matrix(y_true, y_pred))\n",
        "    print(\"Cohen Kappa Score:\", cohen_kappa_score(y_true, y_pred))\n",
        "    print(\"Classification Report:\\n\", classification_report(y_true, y_pred, target_names=target_names))\n",
        "\n",
        "#  function to view one image\n",
        "def image_show(np_image):\n",
        "  plt.figure(figsize = (5,5))\n",
        "  plt.imshow(np_image) # it should be a numpy array\n",
        "  plt.show()\n"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xrtimqL20B8Y"
      },
      "source": [
        "## Load the trained MVNN models"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cpZXxMnBeXbU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b2e887b2-d36a-49cf-a350-7e20195a9cdb"
      },
      "source": [
        "modelname = 'MVNN_wout_pixel'    # Which model to use?\n",
        "\n",
        "if modelname == 'MVNN': # hard-coded\n",
        "  !gdown --id 1-GnaZw9ZsYxq-2LiQtCNuBjtLwZl2T2E\n",
        "  PATH = '/content/MVNN_epoch6_batch32_lr0.0001_seed0_2020-11-03.pt'\n",
        "\n",
        "elif modelname == 'MVNN_wout_freq':\n",
        "  !gdown --id 1-VN60TlFCGZLwv31CVDrY4iUvuaCklsw\n",
        "  PATH = '/content/MVNN_wout_freq_epoch5_batch32_lr0.0001_seed0_2020-11-04.pt'\n",
        "\n",
        "elif modelname == 'MVNN_wout_pixel':\n",
        "  !gdown --id 1-4Z0fbUB6jEJMHaxPaxBMn00d3h4eTZm\n",
        "  PATH = '/content/MVNN_wout_pixel_epoch11_batch32_lr0.0001_seed0_2020-11-04.pt'\n",
        "\n",
        "elif modelname == 'MVNN_wout_att':\n",
        "  !gdown --id 1-PG9pKQ7TsLNzSBa1qU25-kXsU5M6H1h\n",
        "  PATH = '/content/MVNN_wout_att_epoch4_batch32_lr0.0001_seed0_2020-11-03.pt'\n",
        "\n",
        "elif modelname == 'MVNN_wout_GRU':\n",
        "  !gdown --id 1-cLF3ietK0S2Ntgx9dLE1zXo6rjDTYYX\n",
        "  PATH = '/content/MVNN_wout_GRU_epoch7_batch32_lr0.0001_seed0_2020-11-03.pt'\n",
        "\n",
        "elif modelname == 'MVNN_wout_branches':\n",
        "  !gdown --id 1-75gl1akpCGlVcJXuemHBtzNoImWD0Aa\n",
        "  PATH = '/content/MVNN_wout_branches_epoch10_batch32_lr0.0001_seed0_2020-11-03.pt'\n",
        "\n",
        "else:\n",
        "  model = []\n",
        "  print(\"Error: the selected model is not available!\")\n",
        "\n",
        "# Download the trained full MVNN model\n",
        "model = torch.load(PATH)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1-4Z0fbUB6jEJMHaxPaxBMn00d3h4eTZm\n",
            "To: /content/MVNN_wout_pixel_epoch11_batch32_lr0.0001_seed0_2020-11-04.pt\n",
            "\r  0% 0.00/1.23M [00:00<?, ?B/s]\r100% 1.23M/1.23M [00:00<00:00, 81.0MB/s]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lNsR5NuQYnL3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "43da592d-af44-4073-b7c1-162b7a41c573"
      },
      "source": [
        "device = 'cuda'\n",
        "batch_size = 32\n",
        "\n",
        "seed_no = 0\n",
        "torch.set_deterministic = True\n",
        "torch.manual_seed(seed_no)\n",
        "\n",
        "dataset = WeiboRumorDataset(tform_pixel, tform_freq, mainfolder, subfolders)\n",
        "dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True, drop_last=True) \n",
        "\n",
        "report_every = 10\n",
        "acc, loss = 0, 0\n",
        "cnt = 0\n",
        "model.eval()\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    print('\\n===== Start Validating ... =====')\n",
        "    for data in dataloader:\n",
        "        Xp, Xf = data[0].float().to(device), data[1].float().to(device)\n",
        "        y = data[2].to(device)\n",
        "\n",
        "        # prediction\n",
        "        out = model(Xp, Xf)        \n",
        "        pred = torch.argmax(out, dim=1)\n",
        "\n",
        "        y_true.append(y)\n",
        "        y_pred.append(pred)\n",
        "\n",
        "        cnt += 1\n",
        "\n",
        "        if cnt % report_every == 0:\n",
        "            print(\"[Test] %d / %d batches tested\" % (cnt, dataloader.__len__()))        \n",
        "\n",
        "    print(\"[Test] %d / %d batches tested\" % (cnt, dataloader.__len__()))\n",
        "    y_true = torch.cat(y_true, dim=0)\n",
        "    y_pred = torch.cat(y_pred, dim=0)\n",
        "    target_names = ['non-rumor', 'rumor']\n",
        "    print_metrics(y_true.cpu(), y_pred.cpu(), target_names)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[Medieval2015_fake_or_real_Images/non-rumor]: 176 image loaded.\n",
            "[Medieval2015_fake_or_real_Images/rumor]: 184 image loaded.\n",
            "\n",
            "===== Start Validating ... =====\n",
            "[Test] 10 / 11 batches tested\n",
            "[Test] 11 / 11 batches tested\n",
            "Accuracy: 0.4772727272727273\n",
            "Balanced Accuracy: 0.4755707688830045\n",
            "Confusion Matrix:\n",
            " [[ 65 108]\n",
            " [ 76 103]]\n",
            "Cohen Kappa Score: -0.049010398108257025\n",
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "   non-rumor       0.46      0.38      0.41       173\n",
            "       rumor       0.49      0.58      0.53       179\n",
            "\n",
            "    accuracy                           0.48       352\n",
            "   macro avg       0.47      0.48      0.47       352\n",
            "weighted avg       0.47      0.48      0.47       352\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}
